Cosmic Ray Report

Date time: 06/09/2025 22:56:28

Total jobs: 205

Complete: 205 (100.00%)

Surviving mutants: 25 (12.20%)

operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a - b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.53s

operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a - c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.42s

operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b - c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.38s

operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 - sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.45s

operator: core/ReplaceBinaryOperator_Add_Sub, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type - " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type - " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for -: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.42s

operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a * b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
................F.........FF                                             [100%]

================================== FAILURES ===================================

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

3 failed, 25 passed in 0.53s

operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a * c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
............................                                             [100%]

28 passed in 0.35s

operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b * c <= a:
         return "not a triangle"
     
     # Classification by sides
............................                                             [100%]

28 passed in 0.37s

operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 * sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.40s

operator: core/ReplaceBinaryOperator_Add_Mul, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type * " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type * " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: can't multiply sequence by non-int of type 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: can'...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: can'...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: can'...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: can'...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.58s

operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a / b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.49s

operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a / c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.46s

operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b / c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.48s

operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 / sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.52s

operator: core/ReplaceBinaryOperator_Add_Div, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type / " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type / " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for /: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.49s

operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a // b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a // c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.49s

operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b // c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 // sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.37s

operator: core/ReplaceBinaryOperator_Add_FloorDiv, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type // " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type // " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for //: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.48s

operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a % b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.39s

operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a % c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFF.FFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

19 failed, 9 passed in 0.52s

operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b % c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFF.FF....FFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

15 failed, 13 passed in 0.42s

operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 % sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.46s

operator: core/ReplaceBinaryOperator_Add_Mod, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type % " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type % " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: not all arguments converted during string formatting



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: not ...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: not ...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: not ...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: not ...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.42s

operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a ** b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
................F.F.......FF                                             [100%]

================================== FAILURES ===================================

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

4 failed, 24 passed in 0.41s

operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a ** c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
................F...........                                             [100%]

================================== FAILURES ===================================

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

1 failed, 27 passed in 0.41s

operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b ** c <= a:
         return "not a triangle"
     
     # Classification by sides
................F...........                                             [100%]

================================== FAILURES ===================================

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

1 failed, 27 passed in 0.37s

operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 ** sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
timeout
operator: core/ReplaceBinaryOperator_Add_Pow, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type ** " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ** " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a >> b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF......FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 5.1



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 5.0005



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a >> b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...

22 failed, 6 passed in 0.48s

operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a >> c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a >> c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.45s

operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b >> c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b >> c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.50s

operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF..FFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 >> sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

16 failed, 12 passed in 0.41s

operator: core/ReplaceBinaryOperator_Add_RShift, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type >> " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type >> " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.49s

operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a << b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
..FF...FF.....FF..FFF...F.FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides0-not a triangle] ___________________



sides = (1, 2, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides4-not a triangle] ___________________



sides = (1, 10, 12), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 5.1



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 5.0005



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a << b <= c or a + c <= b or b + c <= a:

           ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...

12 failed, 16 passed in 0.44s

operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a << c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
..FF...FF.....FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a << c <= b or b + c <= a:

                         ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

10 failed, 18 passed in 0.41s

operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b << c <= a:
         return "not a triangle"
     
     # Classification by sides
..FF...FF.....FFFFFF.....F..                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b << c <= a:

                                       ^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides5-not a triangle] ___________________



sides = (5, 1, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...

11 failed, 17 passed in 0.44s

operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF..FFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 << sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

16 failed, 12 passed in 0.49s

operator: core/ReplaceBinaryOperator_Add_LShift, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type << " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type << " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.43s

operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a | b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFF...FF...F.FFFFFF......FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 5.1



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 5.0005



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a | b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...

15 failed, 13 passed in 0.45s

operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a | c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFF.FFF.....FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a | c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

14 failed, 14 passed in 0.41s

operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b | c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFF..FF.....FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b | c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.45s

operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 | sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.44s

operator: core/ReplaceBinaryOperator_Add_BitOr, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type | " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type | " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.49s

operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a & b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFF.FFFFF.FFFFFFFFF......FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 5.1



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 5.0005



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a & b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...

20 failed, 8 passed in 0.53s

operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a & c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFF.FFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a & c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

19 failed, 9 passed in 0.46s

operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b & c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFF.FFF.FF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b & c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

16 failed, 12 passed in 0.45s

operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFF.FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 & sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

17 failed, 11 passed in 0.44s

operator: core/ReplaceBinaryOperator_Add_BitAnd, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type & " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type & " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.46s

operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a ^ b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFF.FFF.F.F.FFFFFF......FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 5.1



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:62: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 5.0005



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a ^ b <= c or a + c <= b or b + c <= a:

           ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - TypeError: u...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - TypeError: u...

18 failed, 10 passed in 0.45s

operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a ^ c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFF.FFF..FF.FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a ^ c <= b or b + c <= a:

                         ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

16 failed, 12 passed in 0.49s

operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b ^ c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFF..FFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

>       if a + b <= c or a + c <= b or b ^ c <= a:

                                       ^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:5: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

18 failed, 10 passed in 0.50s

operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 ^ sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.50s

operator: core/ReplaceBinaryOperator_Add_BitXor, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -18,5 +18,5 @@
     if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
-    return triangle_type + " triangle"
+    return triangle_type ^ " triangle"
 
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

        if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:

            triangle_type += " right"

    

>       return triangle_type ^ " triangle"

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'str' and 'str'



HW00b.py:21: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - TypeError...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.49s

operator: core/ReplaceBinaryOperator_Sub_Add, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 + sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.41s

operator: core/ReplaceBinaryOperator_Sub_Mul, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 * sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.37s

operator: core/ReplaceBinaryOperator_Sub_Div, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 / sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.45s

operator: core/ReplaceBinaryOperator_Sub_FloorDiv, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 // sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.43s

operator: core/ReplaceBinaryOperator_Sub_Mod, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 % sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.41s

operator: core/ReplaceBinaryOperator_Sub_Pow, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 ** sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
timeout
operator: core/ReplaceBinaryOperator_Sub_RShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFF...FFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 >> sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

17 failed, 11 passed in 0.39s

operator: core/ReplaceBinaryOperator_Sub_LShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 << sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.46s

operator: core/ReplaceBinaryOperator_Sub_BitOr, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 | sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.45s

operator: core/ReplaceBinaryOperator_Sub_BitAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
F.FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 & sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

14 failed, 14 passed in 0.41s

operator: core/ReplaceBinaryOperator_Sub_BitXor, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FF.....FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 ^ sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

10 failed, 18 passed in 0.52s

operator: core/ReplaceBinaryOperator_Pow_Add, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]+2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.46s

operator: core/ReplaceBinaryOperator_Pow_Add, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]+2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
....F....FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

8 failed, 20 passed in 0.43s

operator: core/ReplaceBinaryOperator_Pow_Add, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]+2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.55s

operator: core/ReplaceBinaryOperator_Pow_Sub, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]-2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
....F....FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

8 failed, 20 passed in 0.40s

operator: core/ReplaceBinaryOperator_Pow_Sub, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]-2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.46s

operator: core/ReplaceBinaryOperator_Pow_Sub, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]-2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.42s

operator: core/ReplaceBinaryOperator_Pow_Mul, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]*2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.40s

operator: core/ReplaceBinaryOperator_Pow_Mul, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]*2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.42s

operator: core/ReplaceBinaryOperator_Pow_Mul, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]*2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.40s

operator: core/ReplaceBinaryOperator_Pow_Div, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]/2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.53s

operator: core/ReplaceBinaryOperator_Pow_Div, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]/2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.44s

operator: core/ReplaceBinaryOperator_Pow_Div, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]/2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.37s

operator: core/ReplaceBinaryOperator_Pow_FloorDiv, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]//2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.44s

operator: core/ReplaceBinaryOperator_Pow_FloorDiv, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]//2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.45s

operator: core/ReplaceBinaryOperator_Pow_FloorDiv, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]//2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.47s

operator: core/ReplaceBinaryOperator_Pow_Mod, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]%2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
....F....FFF.....FFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.40s

operator: core/ReplaceBinaryOperator_Pow_Mod, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]%2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF.....FFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

6 failed, 22 passed in 0.44s

operator: core/ReplaceBinaryOperator_Pow_Mod, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]%2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.39s

operator: core/ReplaceBinaryOperator_Pow_RShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
F.FFF.FFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]>>2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

18 failed, 10 passed in 0.41s

operator: core/ReplaceBinaryOperator_Pow_RShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]>>2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - ValueEr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - ValueEr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.49s

operator: core/ReplaceBinaryOperator_Pow_RShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]>>2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for >>: 'float' and 'int'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.49s

operator: core/ReplaceBinaryOperator_Pow_LShift, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF..FFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]<<2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

16 failed, 12 passed in 0.48s

operator: core/ReplaceBinaryOperator_Pow_LShift, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       ValueError: negative shift count



HW00b.py:18: ValueError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]<<2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - ValueEr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - ValueEr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - ValueError:...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - ValueErro...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - ValueError: neg...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.41s

operator: core/ReplaceBinaryOperator_Pow_LShift, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]<<2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for <<: 'float' and 'int'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.39s

operator: core/ReplaceBinaryOperator_Pow_BitOr, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]|2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.42s

operator: core/ReplaceBinaryOperator_Pow_BitOr, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]|2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.39s

operator: core/ReplaceBinaryOperator_Pow_BitOr, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]|2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for |: 'float' and 'int'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.43s

operator: core/ReplaceBinaryOperator_Pow_BitAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.FFF.FFFFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]&2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

16 failed, 12 passed in 0.43s

operator: core/ReplaceBinaryOperator_Pow_BitAnd, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF.F.FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]&2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

14 failed, 14 passed in 0.49s

operator: core/ReplaceBinaryOperator_Pow_BitAnd, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.FFF.F.FF....FFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]&2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for &: 'float' and 'int'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.41s

operator: core/ReplaceBinaryOperator_Pow_BitXor, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FFF..FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]^2 + sides[1]**2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

14 failed, 14 passed in 0.40s

operator: core/ReplaceBinaryOperator_Pow_BitXor, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'int' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]^2 - sides[2]**2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'float'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.42s

operator: core/ReplaceBinaryOperator_Pow_BitXor, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
..FF...FFFFF..FFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[2]^2) < 1e-9:

               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

E       TypeError: unsupported operand type(s) for ^: 'float' and 'int'



HW00b.py:18: TypeError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - TypeErr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - TypeError: ...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - TypeError: unsu...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

13 failed, 15 passed in 0.47s

operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a != b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFF.F......................                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

5 failed, 23 passed in 0.40s

operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a == b != c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFFF..FF.......FFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

11 failed, 17 passed in 0.37s

operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a != b or b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
....F..FFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

14 failed, 14 passed in 0.37s

operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b != c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.....F...FFFFFFF............                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

8 failed, 20 passed in 0.40s

operator: core/ReplaceComparisonOperator_Eq_NotEq, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c or a != c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
......F..FFFFFFF............                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

8 failed, 20 passed in 0.41s

operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a < b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFF.F......................                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

5 failed, 23 passed in 0.38s

operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a == b < c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFF...FF.......FFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

10 failed, 18 passed in 0.41s

operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a < b or b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
....F..FFF..FFFFFFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

12 failed, 16 passed in 0.59s

operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b < c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.....F...F.FFFFF............                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

7 failed, 21 passed in 0.45s

operator: core/ReplaceComparisonOperator_Eq_Lt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c or a < c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
......F..F.FFFFF............                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

7 failed, 21 passed in 0.39s

operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a <= b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
.....F......................                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

1 failed, 27 passed in 0.39s

operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a == b <= c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
.......FF.......FFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

6 failed, 22 passed in 0.41s

operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a <= b or b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.........F..FFFF............                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

5 failed, 23 passed in 0.42s

operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b <= c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.........F.FFFFF............                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

6 failed, 22 passed in 0.43s

operator: core/ReplaceComparisonOperator_Eq_LtE, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c or a <= c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.........F.FFFFF............                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

6 failed, 22 passed in 0.39s

operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a > b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFF........................                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

4 failed, 24 passed in 0.34s

operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a == b > c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFFF.......................                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

5 failed, 23 passed in 0.39s

operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a > b or b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
....F..FF.FF....FFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

9 failed, 19 passed in 0.40s

operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b > c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.....F....F.................                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

2 failed, 26 passed in 0.36s

operator: core/ReplaceComparisonOperator_Eq_Gt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c or a > c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
......F...F.................                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

2 failed, 26 passed in 0.40s

operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a >= b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
............................                                             [100%]

28 passed in 0.34s

operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a == b >= c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
....F.......................                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

1 failed, 27 passed in 0.38s

operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a >= b or b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
..........FF................                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

2 failed, 26 passed in 0.39s

operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b >= c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
..........F.................                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

1 failed, 27 passed in 0.38s

operator: core/ReplaceComparisonOperator_Eq_GtE, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c or a >= c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
..........F.................                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

1 failed, 27 passed in 0.36s

operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a is b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
............................                                             [100%]

28 passed in 0.31s

operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a == b is c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
............................                                             [100%]

28 passed in 0.33s

operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a is b or b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
............................                                             [100%]

28 passed in 0.37s

operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b is c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
............................                                             [100%]

28 passed in 0.35s

operator: core/ReplaceComparisonOperator_Eq_Is, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c or a is c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
............................                                             [100%]

28 passed in 0.29s

operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a is not b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFF.F......................                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

5 failed, 23 passed in 0.37s

operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if a == b is not c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFFF..FF.......FFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

11 failed, 17 passed in 0.43s

operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a is not b or b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
....F..FFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

14 failed, 14 passed in 0.42s

operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b is not c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.....F...FFFFFFF............                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

8 failed, 20 passed in 0.40s

operator: core/ReplaceComparisonOperator_Eq_IsNot, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c or a is not c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
......F..FFFFFFF............                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?   ^  ^^

E         + isosceles right triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         ?   ^  ^^

E         + isosceles triangle

E         ? +++  ^  ^



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

8 failed, 20 passed in 0.47s

operator: core/ReplaceComparisonOperator_Lt_Eq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) == 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.38s

operator: core/ReplaceComparisonOperator_Lt_NotEq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) != 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFF...FFFF............                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

13 failed, 15 passed in 0.46s

operator: core/ReplaceComparisonOperator_Lt_LtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) <= 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
............................                                             [100%]

28 passed in 0.31s

operator: core/ReplaceComparisonOperator_Lt_Gt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) > 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.47s

operator: core/ReplaceComparisonOperator_Lt_GtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) >= 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.55s

operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a == 0 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.31s

operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b == 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.37s

operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 or c == 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.37s

operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b == c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
........................F.FF                                             [100%]

================================== FAILURES ===================================

__________________ test_not_triangle[sides4-not a triangle] ___________________



sides = (1, 10, 12), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

3 failed, 25 passed in 0.41s

operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c == b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
............................                                             [100%]

28 passed in 0.33s

operator: core/ReplaceComparisonOperator_LtE_Eq, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b + c == a:
         return "not a triangle"
     
     # Classification by sides
.........................F..                                             [100%]

================================== FAILURES ===================================

__________________ test_not_triangle[sides5-not a triangle] ___________________



sides = (5, 1, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...

1 failed, 27 passed in 0.36s

operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a != 0 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.39s

operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b != 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.41s

operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 or c != 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.43s

operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b != c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFFF.......                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides0-not a triangle] ___________________



sides = (1, 2, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...

21 failed, 7 passed in 0.49s

operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c != b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.42s

operator: core/ReplaceComparisonOperator_LtE_NotEq, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b + c != a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.43s

operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a < 0 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.34s

operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b < 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.37s

operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 or c < 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.35s

operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b < c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
....................F.......                                             [100%]

================================== FAILURES ===================================

__________________ test_not_triangle[sides0-not a triangle] ___________________



sides = (1, 2, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...

1 failed, 27 passed in 0.38s

operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c < b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
............................                                             [100%]

28 passed in 0.35s

operator: core/ReplaceComparisonOperator_LtE_Lt, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b + c < a:
         return "not a triangle"
     
     # Classification by sides
............................                                             [100%]

28 passed in 0.35s

operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a > 0 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b > 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.48s

operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 or c > 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.45s

operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b > c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFFF...F.FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides0-not a triangle] ___________________



sides = (1, 2, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides4-not a triangle] ___________________



sides = (1, 10, 12), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

24 failed, 4 passed in 0.44s

operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c > b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.46s

operator: core/ReplaceComparisonOperator_LtE_Gt, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b + c > a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF.....F..                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides5-not a triangle] ___________________



sides = (5, 1, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...

21 failed, 7 passed in 0.42s

operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a >= 0 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.42s

operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b >= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.42s

operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 or c >= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.43s

operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b >= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF....F.FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides4-not a triangle] ___________________



sides = (1, 10, 12), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

23 failed, 5 passed in 0.44s

operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c >= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.43s

operator: core/ReplaceComparisonOperator_LtE_GtE, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b + c >= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF.....F..                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides5-not a triangle] ___________________



sides = (5, 1, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...

21 failed, 7 passed in 0.46s

operator: core/ReplaceComparisonOperator_LtE_Is, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b is c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
........................F.FF                                             [100%]

================================== FAILURES ===================================

__________________ test_not_triangle[sides4-not a triangle] ___________________



sides = (1, 10, 12), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

3 failed, 25 passed in 0.37s

operator: core/ReplaceComparisonOperator_LtE_Is, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c is b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
............................                                             [100%]

28 passed in 0.35s

operator: core/ReplaceComparisonOperator_LtE_Is, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b + c is a:
         return "not a triangle"
     
     # Classification by sides
.........................F..                                             [100%]

================================== FAILURES ===================================

__________________ test_not_triangle[sides5-not a triangle] ___________________



sides = (5, 1, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...

1 failed, 27 passed in 0.41s

operator: core/ReplaceComparisonOperator_LtE_IsNot, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b is not c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFFF.......                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides0-not a triangle] ___________________



sides = (1, 2, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...

21 failed, 7 passed in 0.47s

operator: core/ReplaceComparisonOperator_LtE_IsNot, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c is not b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/ReplaceComparisonOperator_LtE_IsNot, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b or b + c is not a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.46s

operator: core/AddNot, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if not a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/AddNot, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if not a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
FFFFFFFFFFFFFFFFFFFFF...F.FF                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + not a triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + not a triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + not a triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

__________________ test_not_triangle[sides0-not a triangle] ___________________



sides = (1, 2, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides4-not a triangle] ___________________



sides = (1, 10, 12), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

24 failed, 4 passed in 0.45s

operator: core/AddNot, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -6,7 +6,7 @@
         return "not a triangle"
     
     # Classification by sides
-    if a == b == c:
+    if not a == b == c:
         triangle_type = "equilateral"
     elif a == b or b == c or a == c:
         triangle_type = "isosceles"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + isosceles triangle



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + equilateral triangle



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + equilateral right triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + equilateral right triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         + equilateral right triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + equilateral triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + equilateral triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + equilateral triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + equilateral triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + equilateral right triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/AddNot, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if not abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'equilateral right triangle' == 'equilateral triangle'

E         

E         - equilateral triangle

E         + equilateral right triangle

E         ?             ++++++



test_HW00b.py:13: AssertionError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'scalene triangle'

E         

E         - scalene triangle

E         + scalene right triangle

E         ?        ++++++



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - Asserti...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - AssertionError:...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.44s

operator: core/ReplaceOrWithAnd, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 and b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.33s

operator: core/ReplaceOrWithAnd, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 and c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.31s

operator: core/ReplaceOrWithAnd, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c and a + c <= b or b + c <= a:
         return "not a triangle"
     
     # Classification by sides
....................F...F.FF                                             [100%]

================================== FAILURES ===================================

__________________ test_not_triangle[sides0-not a triangle] ___________________



sides = (1, 2, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides4-not a triangle] ___________________



sides = (1, 10, 12), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides6-not a triangle] ___________________



sides = (2.5, 2.5, 5.1), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

__________________ test_not_triangle[sides7-not a triangle] ___________________



sides = (2.5002, 2.5002, 5.0005), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'not a triangle'

E         

E         - not a triangle

E         + isosceles triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_not_triangle[sides0-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides4-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides6-not a triangle] - AssertionErr...

FAILED test_HW00b.py::test_not_triangle[sides7-not a triangle] - AssertionErr...

4 failed, 24 passed in 0.37s

operator: core/ReplaceOrWithAnd, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -2,7 +2,7 @@
     # Check validity
     if a <= 0 or b <= 0 or c <= 0:
         return "not a triangle"
-    if a + b <= c or a + c <= b or b + c <= a:
+    if a + b <= c or a + c <= b and b + c <= a:
         return "not a triangle"
     
     # Classification by sides
.........................F..                                             [100%]

================================== FAILURES ===================================

__________________ test_not_triangle[sides5-not a triangle] ___________________



sides = (5, 1, 3), expected = 'not a triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 2, 3), "not a triangle"),

        ((0, 4, 5), "not a triangle"),

        ((-1, 4, 5), "not a triangle"),

        ((0, 0, 0), "not a triangle"),

        ((1, 10, 12), "not a triangle"),

        ((5, 1, 3), "not a triangle"),

        ((2.5, 2.5, 5.1), "not a triangle"),

        ((2.5002, 2.5002, 5.0005), "not a triangle"),

    ])

    def test_not_triangle(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'not a triangle'

E         

E         - not a triangle

E         + scalene triangle



test_HW00b.py:62: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_not_triangle[sides5-not a triangle] - AssertionErr...

1 failed, 27 passed in 0.42s

operator: core/ReplaceOrWithAnd, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b and b == c or a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
....FF.FF.......FFFF........                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene right triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ? ---  ^  ^

E         + scalene right triangle

E         ?   ^  ^^



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

8 failed, 20 passed in 0.40s

operator: core/ReplaceOrWithAnd, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -8,7 +8,7 @@
     # Classification by sides
     if a == b == c:
         triangle_type = "equilateral"
-    elif a == b or b == c or a == c:
+    elif a == b or b == c and a == c:
         triangle_type = "isosceles"
     else:
         triangle_type = "scalene"
.....FF.....................                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         ? ---  ^  ^

E         + scalene triangle

E         ?   ^  ^^



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

2 failed, 26 passed in 0.43s

operator: core/NumberReplacer, occurrence: 0
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 1 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
................F...........                                             [100%]

================================== FAILURES ===================================

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

1 failed, 27 passed in 0.38s

operator: core/NumberReplacer, occurrence: 1
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= -1 or b <= 0 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.36s

operator: core/NumberReplacer, occurrence: 2
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 1 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
................F...........                                             [100%]

================================== FAILURES ===================================

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'not a triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         + not a triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

1 failed, 27 passed in 0.36s

operator: core/NumberReplacer, occurrence: 3
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= -1 or c <= 0:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.32s

operator: core/NumberReplacer, occurrence: 4
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 or c <= 1:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.31s

operator: core/NumberReplacer, occurrence: 5
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -1,6 +1,6 @@
 def classify_triangle(a: float, b: float, c: float) -> str:
     # Check validity
-    if a <= 0 or b <= 0 or c <= 0:
+    if a <= 0 or b <= 0 or c <= -1:
         return "not a triangle"
     if a + b <= c or a + c <= b or b + c <= a:
         return "not a triangle"
............................                                             [100%]

28 passed in 0.31s

operator: core/NumberReplacer, occurrence: 6
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[ 1]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF................                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

3 failed, 25 passed in 0.36s

operator: core/NumberReplacer, occurrence: 7
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[ -1]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.38s

operator: core/NumberReplacer, occurrence: 8
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]** 3 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF.....FFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

6 failed, 22 passed in 0.35s

operator: core/NumberReplacer, occurrence: 9
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]** 1 + sides[1]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF.....FFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

6 failed, 22 passed in 0.37s

operator: core/NumberReplacer, occurrence: 10
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[ 2]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.44s

operator: core/NumberReplacer, occurrence: 11
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[ 0]**2 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF................                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

3 failed, 25 passed in 0.44s

operator: core/NumberReplacer, occurrence: 12
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]** 3 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF.....FFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

6 failed, 22 passed in 0.41s

operator: core/NumberReplacer, occurrence: 13
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]** 1 - sides[2]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF.....FFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

6 failed, 22 passed in 0.42s

operator: core/NumberReplacer, occurrence: 14
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
FFFFFFFFFFFFFFFFFFFF........                                             [100%]

================================== FAILURES ===================================

________________ test_equilateral[sides0-equilateral triangle] ________________



sides = (3, 3, 3), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

________________ test_equilateral[sides1-equilateral triangle] ________________



sides = (5, 5, 5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 5, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

________________ test_equilateral[sides2-equilateral triangle] ________________



sides = (2.5, 2.5, 2.5), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 2.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

________________ test_equilateral[sides3-equilateral triangle] ________________



sides = (2.5002, 2.5002, 2.5002), expected = 'equilateral triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 3), "equilateral triangle"),

        ((5, 5, 5), "equilateral triangle"),

        #((0, 0, 0), "equilateral triangle"),   # fail

        #((-1, -1, -1), "equilateral triangle"), # fail

        ((2.5, 2.5, 2.5), "equilateral triangle"),

        ((2.5002, 2.5002, 2.5002), "equilateral triangle"),

    ])

    def test_equilateral(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:13: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 2.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

__________________ test_isosceles[sides0-isosceles triangle] __________________



sides = (3, 3, 2), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 2



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

__________________ test_isosceles[sides1-isosceles triangle] __________________



sides = (5, 8, 8), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 8, c = 8



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 7, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 2.5, c = 3.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:24: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 4, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 4, c = 3



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 4, b = 3, c = 5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________________ test_scalene[sides3-scalene triangle] ____________________



sides = (5, 6, 7), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 5, b = 6, c = 7



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________________ test_scalene[sides4-scalene triangle] ____________________



sides = (7, 8, 9), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 7, b = 8, c = 9



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________________ test_scalene[sides5-scalene triangle] ____________________



sides = (2.5, 3.5, 4.5), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5, b = 3.5, c = 4.5



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________________ test_scalene[sides6-scalene triangle] ____________________



sides = (2.5002, 3.5002, 4.5002), expected = 'scalene triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:37: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 3.5002, c = 4.5002



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1, b = 1, c = 1.4142135623730951



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 3, b = 3, c = 4.242640687119285



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 1.5, b = 1.5, c = 2.1213203435596424



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

               ^^^^^^^^^^^^^^^^^^^^^^^^^



test_HW00b.py:48: 

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _



a = 2.5002, b = 2.5002, c = 3.535816748645212



    def classify_triangle(a: float, b: float, c: float) -> str:

        # Check validity

        if a <= 0 or b <= 0 or c <= 0:

            return "not a triangle"

        if a + b <= c or a + c <= b or b + c <= a:

            return "not a triangle"

    

        # Classification by sides

        if a == b == c:

            triangle_type = "equilateral"

        elif a == b or b == c or a == c:

            triangle_type = "isosceles"

        else:

            triangle_type = "scalene"

    

        # Right triangle check

        sides = sorted([a, b, c])

>       if abs(sides[0]**2 + sides[1]**2 - sides[ 3]**2) < 1e-9:

                                           ^^^^^^^^^

E       IndexError: list index out of range



HW00b.py:18: IndexError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_equilateral[sides0-equilateral triangle] - IndexEr...

FAILED test_HW00b.py::test_equilateral[sides1-equilateral triangle] - IndexEr...

FAILED test_HW00b.py::test_equilateral[sides2-equilateral triangle] - IndexEr...

FAILED test_HW00b.py::test_equilateral[sides3-equilateral triangle] - IndexEr...

FAILED test_HW00b.py::test_isosceles[sides0-isosceles triangle] - IndexError:...

FAILED test_HW00b.py::test_isosceles[sides1-isosceles triangle] - IndexError:...

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - IndexError:...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - IndexError:...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - IndexError:...

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - IndexErro...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - IndexErro...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - IndexErro...

FAILED test_HW00b.py::test_scalene[sides3-scalene triangle] - IndexError: lis...

FAILED test_HW00b.py::test_scalene[sides4-scalene triangle] - IndexError: lis...

FAILED test_HW00b.py::test_scalene[sides5-scalene triangle] - IndexError: lis...

FAILED test_HW00b.py::test_scalene[sides6-scalene triangle] - IndexError: lis...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

20 failed, 8 passed in 0.40s

operator: core/NumberReplacer, occurrence: 15
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[ 1]**2) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.34s

operator: core/NumberReplacer, occurrence: 16
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]** 3) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.37s

operator: core/NumberReplacer, occurrence: 17
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]** 1) < 1e-9:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.44s

operator: core/NumberReplacer, occurrence: 18
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1.000000001:
         triangle_type += " right"
     
     return triangle_type + " triangle"
......FFF...................                                             [100%]

================================== FAILURES ===================================

__________________ test_isosceles[sides2-isosceles triangle] __________________



sides = (5, 7, 5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides3-isosceles triangle] __________________



sides = (2.5, 2.5, 3.5), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

__________________ test_isosceles[sides4-isosceles triangle] __________________



sides = (2.5002, 2.5002, 3.5002), expected = 'isosceles triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 3, 2), "isosceles triangle"),

        ((5, 8, 8), "isosceles triangle"),

        ((5, 7, 5), "isosceles triangle"),

        ((2.5, 2.5, 3.5), "isosceles triangle"),

        ((2.5002, 2.5002, 3.5002), "isosceles triangle"),

    ])

    def test_isosceles(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles right triangle' == 'isosceles triangle'

E         

E         - isosceles triangle

E         + isosceles right triangle

E         ?           ++++++



test_HW00b.py:24: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_isosceles[sides2-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides3-isosceles triangle] - AssertionEr...

FAILED test_HW00b.py::test_isosceles[sides4-isosceles triangle] - AssertionEr...

3 failed, 25 passed in 0.37s

operator: core/NumberReplacer, occurrence: 19
--- mutation diff ---
--- aHW00b.py
+++ bHW00b.py
@@ -15,7 +15,7 @@
     
     # Right triangle check
     sides = sorted([a, b, c])
-    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < 1e-9:
+    if abs(sides[0]**2 + sides[1]**2 - sides[2]**2) < -0.999999999:
         triangle_type += " right"
     
     return triangle_type + " triangle"
.........FFF....FFFF........                                             [100%]

================================== FAILURES ===================================

_________________ test_scalene[sides0-scalene right triangle] _________________



sides = (3, 4, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides1-scalene right triangle] _________________



sides = (5, 4, 3), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

_________________ test_scalene[sides2-scalene right triangle] _________________



sides = (4, 3, 5), expected = 'scalene right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((3, 4, 5), "scalene right triangle"),

        ((5, 4, 3), "scalene right triangle"),

        ((4, 3, 5), "scalene right triangle"),

        ((5, 6, 7), "scalene triangle"),

        ((7, 8, 9), "scalene triangle"),

        ((2.5, 3.5, 4.5), "scalene triangle"),

        ((2.5002, 3.5002, 4.5002), "scalene triangle"),

    ])

    def test_scalene(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'scalene triangle' == 'scalene right triangle'

E         

E         - scalene right triangle

E         ?        ------

E         + scalene triangle



test_HW00b.py:37: AssertionError

____________ test_isosceles_right[sides0-isosceles right triangle] ____________



sides = (1, 1, 1.4142135623730951), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides1-isosceles right triangle] ____________



sides = (3, 3, 4.242640687119285), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides2-isosceles right triangle] ____________



sides = (1.5, 1.5, 2.1213203435596424), expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

____________ test_isosceles_right[sides3-isosceles right triangle] ____________



sides = (2.5002, 2.5002, 3.535816748645212)

expected = 'isosceles right triangle'



    @pytest.mark.parametrize("sides, expected", [

        ((1, 1, 2**0.5), "isosceles right triangle"),

        #((2, 2, (2*2)**0.5), "isosceles right triangle"), # fail

        ((3, 3, (2*3**2)**0.5), "isosceles right triangle"),

        ((1.5, 1.5, (2*1.5**2)**0.5), "isosceles right triangle"),

        ((2.5002, 2.5002, (2*2.5002**2)**0.5), "isosceles right triangle"),

    ])

    def test_isosceles_right(sides, expected):

>       assert classify_triangle(*sides) == expected

E       AssertionError: assert 'isosceles triangle' == 'isosceles right triangle'

E         

E         - isosceles right triangle

E         ?           ------

E         + isosceles triangle



test_HW00b.py:48: AssertionError

=========================== short test summary info ===========================

FAILED test_HW00b.py::test_scalene[sides0-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides1-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_scalene[sides2-scalene right triangle] - Assertion...

FAILED test_HW00b.py::test_isosceles_right[sides0-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides1-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides2-isosceles right triangle]

FAILED test_HW00b.py::test_isosceles_right[sides3-isosceles right triangle]

7 failed, 21 passed in 0.39s